home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / Drag.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  13.8 KB  |  412 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Drag.p
  3.  
  4.      Contains:    Drag and Drop Interfaces.
  5.  
  6.      Version:    Technology:    Macintosh Drag and Drop 1.1
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Drag;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __DRAG__}
  30. {$SETC __DRAG__ := 1}
  31.  
  32. {$I+}
  33. {$SETC DragIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __APPLEEVENTS__}
  38. {$I AppleEvents.p}
  39. {$ENDC}
  40. {    Errors.p                                                    }
  41. {        ConditionalMacros.p                                        }
  42. {    Types.p                                                        }
  43. {    Memory.p                                                    }
  44. {        MixedMode.p                                                }
  45. {    OSUtils.p                                                    }
  46. {    Events.p                                                    }
  47. {        Quickdraw.p                                                }
  48. {            QuickdrawText.p                                        }
  49. {    EPPC.p                                                        }
  50. {        AppleTalk.p                                                }
  51. {        Files.p                                                    }
  52. {        PPCToolbox.p                                            }
  53. {        Processes.p                                                }
  54. {    Notification.p                                                }
  55.  
  56. {$IFC UNDEFINED __TEXTEDIT__}
  57. {$I TextEdit.p}
  58. {$ENDC}
  59.  
  60. {$PUSH}
  61. {$ALIGN MAC68K}
  62. {$LibExport+}
  63.  
  64. CONST
  65. { Flavor Flags }
  66.     flavorSenderOnly            = $00000001;                    { flavor is available to sender only }
  67.     flavorSenderTranslated        = $00000002;                    { flavor is translated by sender }
  68.     flavorNotSaved                = $00000004;                    { flavor should not be saved }
  69.     flavorSystemTranslated        = $00000100;                    { flavor is translated by system }
  70.  
  71.     
  72. TYPE
  73.     FlavorFlags = LONGINT;
  74.  
  75.  
  76. CONST
  77. { Drag Attributes }
  78.     dragHasLeftSenderWindow        = $00000001;                    { drag has left the source window since TrackDrag }
  79.     dragInsideSenderApplication    = $00000002;                    { drag is occurring within the sender application }
  80.     dragInsideSenderWindow        = $00000004;                    { drag is occurring within the sender window }
  81.  
  82.     
  83. TYPE
  84.     DragAttributes = LONGINT;
  85.  
  86.  
  87. CONST
  88. { Special Flavor Types }
  89.     flavorTypeHFS                = 'hfs ';                        { flavor type for HFS data }
  90.     flavorTypePromiseHFS        = 'phfs';                        { flavor type for promised HFS data }
  91.     flavorTypeDirectory            = 'diry';
  92.  
  93. { Drag Tracking Handler Messages }
  94.     dragTrackingEnterHandler    = 1;                            { drag has entered handler }
  95.     dragTrackingEnterWindow        = 2;                            { drag has entered window }
  96.     dragTrackingInWindow        = 3;                            { drag is moving within window }
  97.     dragTrackingLeaveWindow        = 4;                            { drag has exited window }
  98.     dragTrackingLeaveHandler    = 5;                            { drag has exited handler }
  99.  
  100.     
  101. TYPE
  102.     DragTrackingMessage = INTEGER;
  103.  
  104.  
  105. CONST
  106. { Drag Drawing Procedure Messages }
  107.     dragRegionBegin                = 1;                            { initialize drawing }
  108.     dragRegionDraw                = 2;                            { draw drag feedback }
  109.     dragRegionHide                = 3;                            { hide drag feedback }
  110.     dragRegionIdle                = 4;                            { drag feedback idle time }
  111.     dragRegionEnd                = 5;                            { end of drawing }
  112.  
  113.     
  114. TYPE
  115.     DragRegionMessage = INTEGER;
  116.  
  117.  
  118. CONST
  119. { Zoom Acceleration }
  120.     zoomNoAcceleration            = 0;                            { use linear interpolation }
  121.     zoomAccelerate                = 1;                            { ramp up step size }
  122.     zoomDecelerate                = 2;                            { ramp down step size }
  123.  
  124.     
  125. TYPE
  126.     ZoomAcceleration = INTEGER;
  127.  
  128. { Drag Manager Data Types }
  129.     DragReference = LONGINT;
  130.  
  131.     ItemReference = LONGINT;
  132.  
  133.     FlavorType = ResType;
  134.  
  135. { HFS Flavors }
  136.     HFSFlavor = RECORD
  137.         fileType:                OSType;                                    { file type }
  138.         fileCreator:            OSType;                                    { file creator }
  139.         fdFlags:                INTEGER;                                { Finder flags }
  140.         fileSpec:                FSSpec;                                    { file system specification }
  141.     END;
  142.  
  143.     PromiseHFSFlavor = RECORD
  144.         fileType:                OSType;                                    { file type }
  145.         fileCreator:            OSType;                                    { file creator }
  146.         fdFlags:                INTEGER;                                { Finder flags }
  147.         promisedFlavor:            FlavorType;                                { promised flavor containing an FSSpec }
  148.     END;
  149.  
  150. { Application-Defined Drag Handler Routines }
  151.     DragTrackingHandlerProcPtr = ProcPtr;  { FUNCTION DragTrackingHandler(message: DragTrackingMessage; theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  152.     DragTrackingHandlerUPP = UniversalProcPtr;
  153.  
  154. CONST
  155.     uppDragTrackingHandlerProcInfo = $00003FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  156.  
  157. FUNCTION NewDragTrackingHandlerProc(userRoutine: DragTrackingHandlerProcPtr): DragTrackingHandlerUPP;
  158.     {$IFC NOT GENERATINGCFM }
  159.     INLINE $2E9F;
  160.     {$ENDC}
  161.  
  162. FUNCTION CallDragTrackingHandlerProc(message: DragTrackingMessage; theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragTrackingHandlerUPP): OSErr;
  163.     {$IFC NOT GENERATINGCFM}
  164.     INLINE $205F, $4E90;
  165.     {$ENDC}
  166.     
  167. TYPE
  168.     DragTrackingHandler = DragTrackingHandlerUPP;
  169.  
  170.     DragReceiveHandlerProcPtr = ProcPtr;  { FUNCTION DragReceiveHandler(theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  171.     DragReceiveHandlerUPP = UniversalProcPtr;
  172.  
  173. CONST
  174.     uppDragReceiveHandlerProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  175.  
  176. FUNCTION NewDragReceiveHandlerProc(userRoutine: DragReceiveHandlerProcPtr): DragReceiveHandlerUPP;
  177.     {$IFC NOT GENERATINGCFM }
  178.     INLINE $2E9F;
  179.     {$ENDC}
  180.  
  181. FUNCTION CallDragReceiveHandlerProc(theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragReceiveHandlerUPP): OSErr;
  182.     {$IFC NOT GENERATINGCFM}
  183.     INLINE $205F, $4E90;
  184.     {$ENDC}
  185.     
  186. TYPE
  187.     DragReceiveHandler = DragReceiveHandlerUPP;
  188.  
  189. { Application-Defined Routines }
  190.     DragSendDataProcPtr = ProcPtr;  { FUNCTION DragSendData(theType: FlavorType; dragSendRefCon: UNIV Ptr; theItemRef: ItemReference; theDragRef: DragReference): OSErr; }
  191.     DragSendDataUPP = UniversalProcPtr;
  192.  
  193. CONST
  194.     uppDragSendDataProcInfo = $00003FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  195.  
  196. FUNCTION NewDragSendDataProc(userRoutine: DragSendDataProcPtr): DragSendDataUPP;
  197.     {$IFC NOT GENERATINGCFM }
  198.     INLINE $2E9F;
  199.     {$ENDC}
  200.  
  201. FUNCTION CallDragSendDataProc(theType: FlavorType; dragSendRefCon: UNIV Ptr; theItemRef: ItemReference; theDragRef: DragReference; userRoutine: DragSendDataUPP): OSErr;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $205F, $4E90;
  204.     {$ENDC}
  205.     
  206. TYPE
  207.     DragSendDataProc = DragSendDataUPP;
  208.  
  209.     DragInputProcPtr = ProcPtr;  { FUNCTION DragInput(VAR mouse: Point; VAR modifiers: INTEGER; dragInputRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  210.     DragInputUPP = UniversalProcPtr;
  211.  
  212. CONST
  213.     uppDragInputProcInfo = $00003FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  214.  
  215. FUNCTION NewDragInputProc(userRoutine: DragInputProcPtr): DragInputUPP;
  216.     {$IFC NOT GENERATINGCFM }
  217.     INLINE $2E9F;
  218.     {$ENDC}
  219.  
  220. FUNCTION CallDragInputProc(VAR mouse: Point; VAR modifiers: INTEGER; dragInputRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragInputUPP): OSErr;
  221.     {$IFC NOT GENERATINGCFM}
  222.     INLINE $205F, $4E90;
  223.     {$ENDC}
  224.     
  225. TYPE
  226.     DragInputProc = DragInputUPP;
  227.  
  228.     DragDrawingProcPtr = ProcPtr;  { FUNCTION DragDrawing(message: DragRegionMessage; showRegion: RgnHandle; showOrigin: Point; hideRegion: RgnHandle; hideOrigin: Point; dragDrawingRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  229.     DragDrawingUPP = UniversalProcPtr;
  230.  
  231. CONST
  232.     uppDragDrawingProcInfo = $000FFFA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  233.  
  234. FUNCTION NewDragDrawingProc(userRoutine: DragDrawingProcPtr): DragDrawingUPP;
  235.     {$IFC NOT GENERATINGCFM }
  236.     INLINE $2E9F;
  237.     {$ENDC}
  238.  
  239. FUNCTION CallDragDrawingProc(message: DragRegionMessage; showRegion: RgnHandle; showOrigin: Point; hideRegion: RgnHandle; hideOrigin: Point; dragDrawingRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragDrawingUPP): OSErr;
  240.     {$IFC NOT GENERATINGCFM}
  241.     INLINE $205F, $4E90;
  242.     {$ENDC}
  243.     
  244. TYPE
  245.     DragDrawingProc = DragDrawingUPP;
  246.  
  247. { Drag Manager Routines }
  248. { Installing and Removing Drag Handlers }
  249.  
  250. FUNCTION InstallTrackingHandler(trackingHandler: DragTrackingHandler; theWindow: WindowPtr; handlerRefCon: UNIV Ptr): OSErr;
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $7001, $ABED;
  253.     {$ENDC}
  254. FUNCTION InstallReceiveHandler(receiveHandler: DragReceiveHandler; theWindow: WindowPtr; handlerRefCon: UNIV Ptr): OSErr;
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $7002, $ABED;
  257.     {$ENDC}
  258. FUNCTION RemoveTrackingHandler(trackingHandler: DragTrackingHandler; theWindow: WindowPtr): OSErr;
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $7003, $ABED;
  261.     {$ENDC}
  262. FUNCTION RemoveReceiveHandler(receiveHandler: DragReceiveHandler; theWindow: WindowPtr): OSErr;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $7004, $ABED;
  265.     {$ENDC}
  266. { Creating and Disposing Drag References }
  267. FUNCTION NewDrag(VAR theDragRef: DragReference): OSErr;
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $7005, $ABED;
  270.     {$ENDC}
  271. FUNCTION DisposeDrag(theDragRef: DragReference): OSErr;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $7006, $ABED;
  274.     {$ENDC}
  275. { Adding Drag Item Flavors }
  276. FUNCTION AddDragItemFlavor(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; dataPtr: UNIV Ptr; dataSize: Size; theFlags: FlavorFlags): OSErr;
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $7007, $ABED;
  279.     {$ENDC}
  280. FUNCTION SetDragItemFlavorData(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; dataPtr: UNIV Ptr; dataSize: Size; dataOffset: LONGINT): OSErr;
  281.     {$IFC NOT GENERATINGCFM}
  282.     INLINE $7009, $ABED;
  283.     {$ENDC}
  284. { Providing Drag Callback Procedures }
  285. FUNCTION SetDragSendProc(theDragRef: DragReference; sendProc: DragSendDataProc; dragSendRefCon: UNIV Ptr): OSErr;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $700A, $ABED;
  288.     {$ENDC}
  289. FUNCTION SetDragInputProc(theDragRef: DragReference; inputProc: DragInputProc; dragInputRefCon: UNIV Ptr): OSErr;
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $700B, $ABED;
  292.     {$ENDC}
  293. FUNCTION SetDragDrawingProc(theDragRef: DragReference; drawingProc: DragDrawingProc; dragDrawingRefCon: UNIV Ptr): OSErr;
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $700C, $ABED;
  296.     {$ENDC}
  297. FUNCTION TrackDrag(theDragRef: DragReference; {CONST}VAR theEvent: EventRecord; theRegion: RgnHandle): OSErr;
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $700D, $ABED;
  300.     {$ENDC}
  301. { Getting Drag Item Information }
  302. FUNCTION CountDragItems(theDragRef: DragReference; VAR numItems: INTEGER): OSErr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $700E, $ABED;
  305.     {$ENDC}
  306. FUNCTION GetDragItemReferenceNumber(theDragRef: DragReference; index: INTEGER; VAR theItemRef: ItemReference): OSErr;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $700F, $ABED;
  309.     {$ENDC}
  310. FUNCTION CountDragItemFlavors(theDragRef: DragReference; theItemRef: ItemReference; VAR numFlavors: INTEGER): OSErr;
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $7010, $ABED;
  313.     {$ENDC}
  314. FUNCTION GetFlavorType(theDragRef: DragReference; theItemRef: ItemReference; index: INTEGER; VAR theType: FlavorType): OSErr;
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $7011, $ABED;
  317.     {$ENDC}
  318. FUNCTION GetFlavorFlags(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; VAR theFlags: FlavorFlags): OSErr;
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $7012, $ABED;
  321.     {$ENDC}
  322. FUNCTION GetFlavorDataSize(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; VAR dataSize: Size): OSErr;
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $7013, $ABED;
  325.     {$ENDC}
  326. FUNCTION GetFlavorData(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; dataPtr: UNIV Ptr; VAR dataSize: Size; dataOffset: LONGINT): OSErr;
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $7014, $ABED;
  329.     {$ENDC}
  330. FUNCTION GetDragItemBounds(theDragRef: DragReference; theItemRef: ItemReference; VAR itemBounds: Rect): OSErr;
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $7015, $ABED;
  333.     {$ENDC}
  334. FUNCTION SetDragItemBounds(theDragRef: DragReference; theItemRef: ItemReference; {CONST}VAR itemBounds: Rect): OSErr;
  335.     {$IFC NOT GENERATINGCFM}
  336.     INLINE $7016, $ABED;
  337.     {$ENDC}
  338. FUNCTION GetDropLocation(theDragRef: DragReference; VAR dropLocation: AEDesc): OSErr;
  339.     {$IFC NOT GENERATINGCFM}
  340.     INLINE $7017, $ABED;
  341.     {$ENDC}
  342. FUNCTION SetDropLocation(theDragRef: DragReference; {CONST}VAR dropLocation: AEDesc): OSErr;
  343.     {$IFC NOT GENERATINGCFM}
  344.     INLINE $7018, $ABED;
  345.     {$ENDC}
  346. { Getting Information About a Drag }
  347. FUNCTION GetDragAttributes(theDragRef: DragReference; VAR flags: DragAttributes): OSErr;
  348.     {$IFC NOT GENERATINGCFM}
  349.     INLINE $7019, $ABED;
  350.     {$ENDC}
  351. FUNCTION GetDragMouse(theDragRef: DragReference; VAR mouse: Point; VAR pinnedMouse: Point): OSErr;
  352.     {$IFC NOT GENERATINGCFM}
  353.     INLINE $701A, $ABED;
  354.     {$ENDC}
  355. FUNCTION SetDragMouse(theDragRef: DragReference; pinnedMouse: Point): OSErr;
  356.     {$IFC NOT GENERATINGCFM}
  357.     INLINE $701B, $ABED;
  358.     {$ENDC}
  359. FUNCTION GetDragOrigin(theDragRef: DragReference; VAR initialMouse: Point): OSErr;
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $701C, $ABED;
  362.     {$ENDC}
  363. FUNCTION GetDragModifiers(theDragRef: DragReference; VAR modifiers: INTEGER; VAR mouseDownModifiers: INTEGER; VAR mouseUpModifiers: INTEGER): OSErr;
  364.     {$IFC NOT GENERATINGCFM}
  365.     INLINE $701D, $ABED;
  366.     {$ENDC}
  367. { Drag Highlighting }
  368. FUNCTION ShowDragHilite(theDragRef: DragReference; hiliteFrame: RgnHandle; inside: BOOLEAN): OSErr;
  369.     {$IFC NOT GENERATINGCFM}
  370.     INLINE $701E, $ABED;
  371.     {$ENDC}
  372. FUNCTION HideDragHilite(theDragRef: DragReference): OSErr;
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $701F, $ABED;
  375.     {$ENDC}
  376. FUNCTION DragPreScroll(theDragRef: DragReference; dH: INTEGER; dV: INTEGER): OSErr;
  377.     {$IFC NOT GENERATINGCFM}
  378.     INLINE $7020, $ABED;
  379.     {$ENDC}
  380. FUNCTION DragPostScroll(theDragRef: DragReference): OSErr;
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $7021, $ABED;
  383.     {$ENDC}
  384. FUNCTION UpdateDragHilite(theDragRef: DragReference; updateRgn: RgnHandle): OSErr;
  385.     {$IFC NOT GENERATINGCFM}
  386.     INLINE $7022, $ABED;
  387.     {$ENDC}
  388. { Drag Manager Utilities }
  389. FUNCTION WaitMouseMoved(initialMouse: Point): BOOLEAN;
  390.     {$IFC NOT GENERATINGCFM}
  391.     INLINE $7023, $ABED;
  392.     {$ENDC}
  393. FUNCTION ZoomRects({CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect; zoomSteps: INTEGER; acceleration: ZoomAcceleration): OSErr;
  394.     {$IFC NOT GENERATINGCFM}
  395.     INLINE $7024, $ABED;
  396.     {$ENDC}
  397. FUNCTION ZoomRegion(region: RgnHandle; zoomDistance: Point; zoomSteps: INTEGER; acceleration: ZoomAcceleration): OSErr;
  398.     {$IFC NOT GENERATINGCFM}
  399.     INLINE $7025, $ABED;
  400.     {$ENDC}
  401.  
  402. {$ALIGN RESET}
  403. {$POP}
  404.  
  405. {$SETC UsingIncludes := DragIncludes}
  406.  
  407. {$ENDC} {__DRAG__}
  408.  
  409. {$IFC NOT UsingIncludes}
  410.  END.
  411. {$ENDC}
  412.